home *** CD-ROM | disk | FTP | other *** search
/ MacHack 1997 / MacHack 1997.toast / Hacks / Hacks ’97 / Warrior’s Progress / source code / Source / Libraries / Idle / Delayer.cp < prev    next >
Encoding:
Text File  |  1997-06-28  |  1.8 KB  |  122 lines  |  [TEXT/CWIE]
  1. // Delayer.cp
  2.  
  3. #ifndef Delayer_h
  4. #include "Delayer.h"
  5. #endif
  6.  
  7. Delayer::Delayer( const Method& method )
  8.   : postponer( method ),
  9.      when( 0 ),
  10.      delayLink( this )
  11.   {
  12.     Waiting();
  13.   }
  14.  
  15. Delayer::~Delayer()
  16.   {
  17.   }
  18.  
  19. Heap<Delayer>& Delayer::Waiting()
  20.   {
  21.     static Heap<Delayer> waiting( &Delayer::Before );
  22.     return waiting;
  23.   }
  24.  
  25. bool Delayer::Before( const Delayer& r ) const
  26.   {
  27.     Assert( Pending() );
  28.     Assert( r.Pending() );
  29.     return when <= r.when;
  30.   }
  31.  
  32. void Delayer::DelayBy( uint32 time )
  33.   {
  34.     // Comparing times doesn't work if
  35.     // the times get too far into the future.
  36.     Assert( time < maxuint32 / 4 );
  37.     
  38.     DelayTo( Tick::Now() + time );
  39.   }
  40.  
  41. void Delayer::DelayTo( Tick time )
  42.   {
  43.     Assert( !Pending() )
  44.     when = time;
  45.     
  46.     if ( time <= Tick::Now() )
  47.         postponer.Schedule();
  48.      else
  49.         Waiting().Add( delayLink );
  50.   }
  51.  
  52. void Delayer::Cancel()
  53.   {
  54.     Assert( Pending() );
  55.     if ( postponer.Pending() )
  56.         postponer.Cancel();
  57.      else
  58.         Waiting().Remove( delayLink );
  59.   }
  60.  
  61. void Delayer::Hasten()
  62.   {
  63.     if ( delayLink.Listed() )
  64.       {
  65.         Waiting().Remove( delayLink );
  66.         postponer.Schedule();
  67.       }
  68.   }
  69.     
  70. void Delayer::Flush()
  71.   {
  72.     if ( !Pending() )
  73.         return;
  74.     
  75.     Hasten();
  76.     postponer.Flush();
  77.   }
  78.  
  79. void Delayer::ScheduleTasks()
  80.   {
  81.     Tick now( Tick::Now() );
  82.     Heap<Delayer>& waiting( Waiting() );
  83.     
  84.     while ( !waiting.IsEmpty() )
  85.       {
  86.         Delayer& task = *waiting.Top();
  87.         
  88.         if ( task.when > now )
  89.             break;
  90.         
  91.         waiting.Remove( task.delayLink );
  92.         task.postponer.Schedule();
  93.       }
  94.   }
  95.  
  96. uint32 Delayer::SleepTime()
  97.   {
  98.     if ( !Postponer::CanSleep() )
  99.         return 0;
  100.  
  101.     Heap<Delayer>& waiting( Waiting() );
  102.     
  103.     if ( waiting.IsEmpty() )
  104.         return maxint32;
  105.     
  106.     Tick nextTime( waiting.Top()->when );
  107.     Tick now( Tick::Now() );
  108.     
  109.     if ( nextTime <= now )
  110.         return 0;
  111.     
  112.     return nextTime - now;
  113.   }
  114.  
  115. bool Delayer::Pending() const
  116.   {
  117.     return delayLink.Listed() || postponer.Pending();
  118.   }
  119.  
  120. #include "Heap.cp"
  121. #include "HeapLink.cp"
  122.